ಪರಿಣಾಮಕಾರಿ ಸಂಯೋಜಿತ ಪುನರಾವರ್ತನೆಗಾಗಿ ಪೈಥಾನ್‌ನ itertools ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸುಧಾರಿತ ಮಾದರಿಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಿ. ಪ್ರಾಯೋಗಿಕ, ಜಾಗತಿಕ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಪರ್ಮುಟೇಶನ್‌ಗಳು, ಕಾಂಬಿನೇಶನ್‌ಗಳು ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ಅನ್ವೇಷಿಸಿ.
Itertools ಸುಧಾರಿತ ಮಾದರಿಗಳು: ಪೈಥಾನ್‌ನಲ್ಲಿ ಸಂಯೋಜಿತ ಇಟೆರೇಟರ್ ಕಾರ್ಯಗಳನ್ನು ಅನಾವರಣಗೊಳಿಸುವುದು
ಪೈಥಾನ್‌ನ itertools ಮಾಡ್ಯೂಲ್ ಮೆಮೊರಿ-ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ಸೊಗಸಾದ ರೀತಿಯಲ್ಲಿ ಇಟೆರೇಟರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಉಪಕರಣಗಳ ನಿಧಿಯಾಗಿದೆ. ಅನೇಕ ಡೆವಲಪರ್‌ಗಳು ಮೂಲಭೂತ ಇಟೆರೇಟರ್ ತಂತ್ರಗಳೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿದ್ದರೂ, itertools ನ ನಿಜವಾದ ಶಕ್ತಿಯು ಅದರ ಸಂಯೋಜಿತ ಇಟೆರೇಟರ್ ಕಾರ್ಯಗಳಲ್ಲಿದೆ. ಈ ಕಾರ್ಯಗಳು ಕನಿಷ್ಠ ಕೋಡ್‌ನೊಂದಿಗೆ ಡೇಟಾದ ವಿವಿಧ ಸಂಯೋಜನೆಗಳು, ಪರ್ಮುಟೇಶನ್‌ಗಳು ಮತ್ತು ಇತರ ವ್ಯವಸ್ಥೆಗಳನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ ಈ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸುಧಾರಿತ ಮಾದರಿಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗೆ ಸೂಕ್ತವಾದ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಇಟೆರೇಟರ್‌ಗಳು ಮತ್ತು ಜನರೇಟರ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಸಂಯೋಜಿತ ಕಾರ್ಯಗಳ ನಿರ್ದಿಷ್ಟತೆಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು, ಇಟೆರೇಟರ್‌ಗಳು ಮತ್ತು ಜನರೇಟರ್‌ಗಳ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಒಂದು ಇಟೆರೇಟರ್ ಎನ್ನುವುದು ಮೌಲ್ಯಗಳ ಅನುಕ್ರಮದ ಮೂಲಕ ಸಂಚರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಒಂದು ವಸ್ತು. ಒಂದು ಜನರೇಟರ್ ಎನ್ನುವುದು ಒಂದು ವಿಶೇಷ ರೀತಿಯ ಇಟೆರೇಟರ್ ಆಗಿದ್ದು, ಅದು ಮೌಲ್ಯಗಳನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುವ ಬದಲು ತಕ್ಷಣವೇ ರಚಿಸುತ್ತದೆ. ಇದು ಜನರೇಟರ್‌ಗಳನ್ನು ಅತಿ ಹೆಚ್ಚು ಮೆಮೊರಿ-ಪರಿಣಾಮಕಾರಿ ಮಾಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ.
itertools ಮಾಡ್ಯೂಲ್ ವಿವಿಧ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯಗಳಿಗೆ ಪರಿಣಾಮಕಾರಿ ಪರಿಹಾರಗಳನ್ನು ಒದಗಿಸಲು ಜನರೇಟರ್‌ಗಳನ್ನು ವ್ಯಾಪಕವಾಗಿ ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ. ಜನರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಈ ಕಾರ್ಯಗಳು ಮೆಮೊರಿ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸದೆ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಇದು ಸಂಕೀರ್ಣ ಲೆಕ್ಕಾಚಾರಗಳು ಮತ್ತು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಗೆ ಅವುಗಳನ್ನು ಸೂಕ್ತವಾಗಿಸುತ್ತದೆ.
ಸಂಯೋಜಿತ ಇಟೆರೇಟರ್ ಕಾರ್ಯಗಳು
itertools ಸಂಯೋಜನೆಗಳು ಮತ್ತು ಪರ್ಮುಟೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ನಿರ್ದಿಷ್ಟವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಹಲವಾರು ಕಾರ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ. ಪ್ರಮುಖವಾದವುಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ:
product(): ಇನ್‌ಪುಟ್ ಇಟೆರೇಬಲ್‌ಗಳ ಕಾರ್ಟೇಶಿಯನ್ ಉತ್ಪನ್ನ.permutations(): ಇಟೆರೇಬಲ್‌ನಲ್ಲಿರುವ ಅಂಶಗಳ ಅನುಕ್ರಮ ಉದ್ದದ ಪರ್ಮುಟೇಶನ್‌ಗಳು.combinations(): ಇಟೆರೇಬಲ್‌ನಲ್ಲಿರುವ ಅಂಶಗಳ ಅನುಕ್ರಮ r ಉದ್ದದ ಸಂಯೋಜನೆಗಳು.combinations_with_replacement(): ಒಂದೇ ಅಂಶವನ್ನು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಪುನರಾವರ್ತಿಸಲು ಅನುಮತಿಸುವ ಇಟೆರೇಬಲ್‌ನಲ್ಲಿರುವ ಅಂಶಗಳ ಅನುಕ್ರಮ r ಉದ್ದದ ಸಂಯೋಜನೆಗಳು.
1. product() ನೊಂದಿಗೆ ಕಾರ್ಟೇಶಿಯನ್ ಉತ್ಪನ್ನ
product() ಕಾರ್ಯವು ಇನ್‌ಪುಟ್ ಇಟೆರೇಬಲ್‌ಗಳ ಕಾರ್ಟೇಶಿಯನ್ ಉತ್ಪನ್ನವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. ಇದರರ್ಥ ಇದು ಪ್ರತಿ ಇಟೆರೇಬಲ್‌ನಿಂದ ಒಂದು ಅಂಶವನ್ನು ತೆಗೆದುಕೊಂಡು ಎಲ್ಲಾ ಸಂಭವನೀಯ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸುತ್ತದೆ. ನೀವು ಹೊಸ ಉತ್ಪನ್ನ ಸಾಲಿಗಾಗಿ ಬಣ್ಣದ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಮೂಲಕ್ಕೆ, ಟ್ರಿಮ್‌ಗೆ ಮತ್ತು ಆಕ್ಸೆಂಟ್‌ಗೆ ಬಣ್ಣಗಳ ಗುಂಪನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ.
ಉದಾಹರಣೆ: ಬಣ್ಣದ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸುವುದು
ಉತ್ಪನ್ನದ ವಿವಿಧ ಭಾಗಗಳಿಗೆ ಬಣ್ಣಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಮೂರು ಪಟ್ಟಿಗಳನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಹೇಳೋಣ:
import itertools
base_colors = ['red', 'blue', 'green']
trim_colors = ['silver', 'gold']
accent_colors = ['white', 'black']
color_combinations = list(itertools.product(base_colors, trim_colors, accent_colors))
print(color_combinations)
ಇದು ಈ ಕೆಳಗಿನಂತೆ ಔಟ್‌ಪುಟ್ ನೀಡುತ್ತದೆ:
[('red', 'silver', 'white'), ('red', 'silver', 'black'), ('red', 'gold', 'white'), ('red', 'gold', 'black'), ('blue', 'silver', 'white'), ('blue', 'silver', 'black'), ('blue', 'gold', 'white'), ('blue', 'gold', 'black'), ('green', 'silver', 'white'), ('green', 'silver', 'black'), ('green', 'gold', 'white'), ('green', 'gold', 'black')]
ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿರುವ ಪ್ರತಿ ಟುಪಲ್ (tuple) ಬೇಸ್, ಟ್ರಿಮ್ ಮತ್ತು ಆಕ್ಸೆಂಟ್ ಬಣ್ಣಗಳ ವಿಶಿಷ್ಟ ಸಂಯೋಜನೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
product() ಗಾಗಿ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು
- ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ರಚಿಸುವುದು: ಸಾಫ್ಟ್‌ವೇರ್ ಕಾರ್ಯಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಎಲ್ಲಾ ಸಂಭವನೀಯ ಇನ್‌ಪುಟ್ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸಿ.
- ಕ್ರಿಪ್ಟೋಗ್ರಫಿ: ಬ್ರೂಟ್-ಫೋರ್ಸ್ ದಾಳಿಗಳಿಗಾಗಿ ಕೀ ಸ್ಪೇಸ್‌ಗಳನ್ನು ರಚಿಸಿ (ಎಚ್ಚರಿಕೆಯಿಂದ ಮತ್ತು ನೈತಿಕ ಪರಿಗಣನೆಗಳೊಂದಿಗೆ ಬಳಸಿ).
- ಕಾನ್ಫಿಗರೇಶನ್ ನಿರ್ವಹಣೆ: ವಿಭಿನ್ನ ನಿಯತಾಂಕಗಳ ಆಧಾರದ ಮೇಲೆ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ರಚಿಸಿ.
- ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳು: ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರೀಕ್ಷೆಗಾಗಿ ಫಿಲ್ಟರ್ ಮಾನದಂಡಗಳ ವಿಭಿನ್ನ ಸಂಯೋಜನೆಗಳನ್ನು ಅನುಕರಿಸುವುದು.
2. permutations() ನೊಂದಿಗೆ ಪರ್ಮುಟೇಶನ್‌ಗಳು
permutations() ಕಾರ್ಯವು ಇಟೆರೇಬಲ್‌ನಲ್ಲಿರುವ ಅಂಶಗಳ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಕ್ರಮಗಳನ್ನು (ಪರ್ಮುಟೇಶನ್‌ಗಳನ್ನು) ರಚಿಸುತ್ತದೆ. ನೀವು ರಚಿಸಬೇಕಾದ ಪರ್ಮುಟೇಶನ್‌ಗಳ ಉದ್ದವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಉದ್ದವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಅದು ಮೂಲ ಇಟೆರೇಬಲ್‌ನ ಅದೇ ಉದ್ದದ ಪರ್ಮುಟೇಶನ್‌ಗಳನ್ನು ರಚಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ: ಕ್ರೀಡಾ ಪಂದ್ಯಾವಳಿಗಾಗಿ ತಂಡದ ಲೈನ್ಅಪ್‌ಗಳು
ನಿಮ್ಮಲ್ಲಿ 4 ಆಟಗಾರರ ತಂಡವಿದೆ ಮತ್ತು ಬೇಸ್‌ಬಾಲ್ ಆಟಕ್ಕಾಗಿ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಬ್ಯಾಟಿಂಗ್ ಆರ್ಡರ್‌ಗಳನ್ನು ನಿರ್ಧರಿಸಬೇಕು ಎಂದು ಭಾವಿಸೋಣ. ಈ ಆಟಗಾರರ ಎಲ್ಲಾ ಸಂಭವನೀಯ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನೀವು ಪರಿಗಣಿಸಲು ಬಯಸುತ್ತೀರಿ.
import itertools
players = ['Alice', 'Bob', 'Charlie', 'David']
team_lineups = list(itertools.permutations(players))
for lineup in team_lineups:
print(lineup)
ಇದು ಎಲ್ಲಾ 24 ಸಂಭವನೀಯ ಬ್ಯಾಟಿಂಗ್ ಆರ್ಡರ್‌ಗಳನ್ನು (4! = 24) ಔಟ್‌ಪುಟ್ ನೀಡುತ್ತದೆ.
('Alice', 'Bob', 'Charlie', 'David')
('Alice', 'Bob', 'David', 'Charlie')
('Alice', 'Charlie', 'Bob', 'David')
('Alice', 'Charlie', 'David', 'Bob')
('Alice', 'David', 'Bob', 'Charlie')
('Alice', 'David', 'Charlie', 'Bob')
('Bob', 'Alice', 'Charlie', 'David')
('Bob', 'Alice', 'David', 'Charlie')
('Bob', 'Charlie', 'Alice', 'David')
('Bob', 'Charlie', 'David', 'Alice')
('Bob', 'David', 'Alice', 'Charlie')
('Bob', 'David', 'Charlie', 'Alice')
('Charlie', 'Alice', 'Bob', 'David')
('Charlie', 'Alice', 'David', 'Bob')
('Charlie', 'Bob', 'Alice', 'David')
('Charlie', 'Bob', 'David', 'Alice')
('Charlie', 'David', 'Alice', 'Bob')
('Charlie', 'David', 'Bob', 'Alice')
('David', 'Alice', 'Bob', 'Charlie')
('David', 'Alice', 'Charlie', 'Bob')
('David', 'Bob', 'Alice', 'Charlie')
('David', 'Bob', 'Charlie', 'Alice')
('David', 'Charlie', 'Alice', 'Bob')
('David', 'Charlie', 'Bob', 'Alice')
ನಿರ್ದಿಷ್ಟ ಉದ್ದದ ಪರ್ಮುಟೇಶನ್‌ಗಳನ್ನು ಪಡೆಯಲು (ಉದಾಹರಣೆಗೆ, ಮೊದಲ 3 ಬ್ಯಾಟರ್‌ಗಳನ್ನು ಆರಿಸುವುದು):
first_three_batters = list(itertools.permutations(players, 3))
for lineup in first_three_batters:
print(lineup)
ಇದು ('Alice', 'Bob', 'Charlie') ನಂತಹ 3 ಉದ್ದದ ಪರ್ಮುಟೇಶನ್‌ಗಳನ್ನು ಔಟ್‌ಪುಟ್ ನೀಡುತ್ತದೆ.
permutations() ಗಾಗಿ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು
- ಪಾಸ್‌ವರ್ಡ್ ಕ್ರ್ಯಾಕಿಂಗ್: ಸಂಭವನೀಯ ಪಾಸ್‌ವರ್ಡ್ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸುವುದು (ಎಚ್ಚರಿಕೆಯಿಂದ ಮತ್ತು ನೈತಿಕ ಪರಿಗಣನೆಗಳೊಂದಿಗೆ, ಮತ್ತು ಭದ್ರತಾ ಪರೀಕ್ಷೆಗಾಗಿ ಸ್ಪಷ್ಟ ಅನುಮತಿಯೊಂದಿಗೆ ಮಾತ್ರ ಬಳಸಿ).
- ಮಾರ್ಗ ಆಪ್ಟಿಮೈಸೇಶನ್: ನಗರಗಳು ಅಥವಾ ಸ್ಥಳಗಳಿಗೆ ಭೇಟಿ ನೀಡುವ ಅತ್ಯುತ್ತಮ ಅನುಕ್ರಮವನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ (ಪ್ರಯಾಣಿಕ ವ್ಯಾಪಾರಿ ಸಮಸ್ಯೆಯ ಅಂದಾಜುಗಳು).
- ಜೆನೆಟಿಕ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳು: ಆಪ್ಟಿಮೈಸೇಶನ್ ಸಮಸ್ಯೆಗಳಿಗಾಗಿ ವಿಭಿನ್ನ ಜೀನ್ ಆರ್ಡರ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸಿ.
- ಕ್ರಿಪ್ಟೋಗ್ರಫಿ: ವಿಭಿನ್ನ ವ್ಯವಸ್ಥೆಗಳ ಮೂಲಕ ಎನ್‌ಕ್ರಿಪ್ಶನ್ ಕೀಗಳನ್ನು ರಚಿಸುವುದು.
3. combinations() ನೊಂದಿಗೆ ಸಂಯೋಜನೆಗಳು
combinations() ಕಾರ್ಯವು ಇಟೆರೇಬಲ್‌ನಿಂದ ಅಂಶಗಳ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಸಂಯೋಜನೆಗಳನ್ನು, ಅವುಗಳ ಕ್ರಮವನ್ನು ಲೆಕ್ಕಿಸದೆ ರಚಿಸುತ್ತದೆ. ಇದು ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್‌ನಂತೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಿರ್ದಿಷ್ಟ ಉದ್ದದ ಸಂಯೋಜನೆಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ: ಜನರ ಗುಂಪಿನಿಂದ ಸಮಿತಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು
ನೀವು 5 ಅಭ್ಯರ್ಥಿಗಳ ಗುಂಪಿನಿಂದ 3 ಜನರ ಸಮಿತಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕೆಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಆಯ್ಕೆಯ ಕ್ರಮವು ಮುಖ್ಯವಲ್ಲ; ಸಮಿತಿಯ ಸದಸ್ಯರು ಮಾತ್ರ ಮುಖ್ಯ.
import itertools
candidates = ['A', 'B', 'C', 'D', 'E']
committee_combinations = list(itertools.combinations(candidates, 3))
for committee in committee_combinations:
print(committee)
ಇದು ಎಲ್ಲಾ 10 ಸಂಭವನೀಯ ಸಮಿತಿಗಳನ್ನು (5 ರಿಂದ 3 ಅನ್ನು ಆರಿಸಿ) ಔಟ್‌ಪುಟ್ ನೀಡುತ್ತದೆ.
('A', 'B', 'C')
('A', 'B', 'D')
('A', 'B', 'E')
('A', 'C', 'D')
('A', 'C', 'E')
('A', 'D', 'E')
('B', 'C', 'D')
('B', 'C', 'E')
('B', 'D', 'E')
('C', 'D', 'E')
combinations() ಗಾಗಿ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು
- ಲಾಟರಿ ಸಂಖ್ಯೆ ರಚನೆ: ಸಂಭವನೀಯ ಲಾಟರಿ ಸಂಖ್ಯೆ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸಿ.
- ವೈಶಿಷ್ಟ್ಯ ಆಯ್ಕೆ: ಮೆಷಿನ್ ಲರ್ನಿಂಗ್ ಮಾದರಿಗಳಿಗಾಗಿ ವೈಶಿಷ್ಟ್ಯಗಳ ಉಪಸಮೂಹಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು.
- ಆಟದ ಅಭಿವೃದ್ಧಿ: ಕಾರ್ಡ್ ಆಟಗಳಲ್ಲಿ ಸಂಭವನೀಯ ಕೈಗಳನ್ನು ರಚಿಸುವುದು.
- ನೆಟ್‌ವರ್ಕ್ ವಿನ್ಯಾಸ: ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಸಂಭವನೀಯ ಸಂಪರ್ಕ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ನಿರ್ಧರಿಸುವುದು.
4. combinations_with_replacement() ನೊಂದಿಗೆ ಬದಲಾವಣೆಯೊಂದಿಗೆ ಸಂಯೋಜನೆಗಳು
combinations_with_replacement() ಕಾರ್ಯವು combinations() ಗೆ ಹೋಲುತ್ತದೆ, ಆದರೆ ಇದು ಸಂಯೋಜನೆಗಳಲ್ಲಿ ಅಂಶಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ನೀವು ಇಟೆರೇಬಲ್‌ನಿಂದ ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಬಯಸಿದಾಗ, ಮತ್ತು ನೀವು ಒಂದೇ ಅಂಶವನ್ನು ಹಲವಾರು ಬಾರಿ ಆಯ್ಕೆ ಮಾಡಬಹುದಾದಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.
ಉದಾಹರಣೆ: ಐಸ್ ಕ್ರೀಮ್ ಫ್ಲೇವರ್‌ಗಳು
ನೀವು 3 ಫ್ಲೇವರ್‌ಗಳೊಂದಿಗೆ (ಚಾಕೊಲೇಟ್, ವೆನಿಲ್ಲಾ ಮತ್ತು ಸ್ಟ್ರಾಬೆರಿ) ಐಸ್ ಕ್ರೀಮ್ ಅಂಗಡಿಯಲ್ಲಿರುವಿರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ನೀವು 2-ಸ್ಕೂಪ್ ಕೋನ್ ರಚಿಸಲು ಬಯಸುತ್ತೀರಿ, ಮತ್ತು ನೀವು ಒಂದೇ ಫ್ಲೇವರ್‌ನ ಎರಡು ಸ್ಕೂಪ್‌ಗಳನ್ನು ಹೊಂದಲು ಅನುಮತಿಸಲಾಗಿದೆ.
import itertools
flavors = ['chocolate', 'vanilla', 'strawberry']
scoop_combinations = list(itertools.combinations_with_replacement(flavors, 2))
for combination in scoop_combinations:
print(combination)
ಇದು ಈ ಕೆಳಗಿನಂತೆ ಔಟ್‌ಪುಟ್ ನೀಡುತ್ತದೆ:
('chocolate', 'chocolate')
('chocolate', 'vanilla')
('chocolate', 'strawberry')
('vanilla', 'vanilla')
('vanilla', 'strawberry')
('strawberry', 'strawberry')
combinations_with_replacement() ಗಾಗಿ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು
- ಅಂಕಿಅಂಶಗಳು: ಬದಲಾವಣೆಯೊಂದಿಗೆ ಮಾದರಿಗಳ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಸಂಯೋಜನೆಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು.
- ಪೂರ್ಣಾಂಕ ವಿಭಜನೆ: ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತವಾಗಿ ಪೂರ್ಣಾಂಕವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಎಲ್ಲಾ ಸಂಭವನೀಯ ಮಾರ್ಗಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು.
- ಇನ್ವೆಂಟರಿ ನಿರ್ವಹಣೆ: ಪುನರಾವರ್ತಿತ ವಸ್ತುಗಳೊಂದಿಗೆ ವಿಭಿನ್ನ ಸ್ಟಾಕ್ ಸಂಯೋಜನೆಗಳನ್ನು ನಿರ್ಧರಿಸುವುದು.
- ಡೇಟಾ ಮಾದರಿ: ಒಂದೇ ಡೇಟಾ ಪಾಯಿಂಟ್ ಅನ್ನು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಆಯ್ಕೆ ಮಾಡಬಹುದಾದ ಮಾದರಿ ಸೆಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು.
ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಂದರ್ಭದೊಂದಿಗೆ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು
ನೈಜ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಈ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ವಿವರಿಸಲು ಅಂತರರಾಷ್ಟ್ರೀಯ ಸಂದರ್ಭದೊಂದಿಗೆ ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.
ಉದಾಹರಣೆ 1: ಕರೆನ್ಸಿ ವಿನಿಮಯ ಸಂಯೋಜನೆಗಳು
ಒಬ್ಬ ಹಣಕಾಸು ವಿಶ್ಲೇಷಕರು ವಿವಿಧ ಕರೆನ್ಸಿ ವಿನಿಮಯ ಸಂಯೋಜನೆಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಲು ಬಯಸುತ್ತಾರೆ. ಅವರು ಪ್ರಮುಖ ಜಾಗತಿಕ ಕರೆನ್ಸಿಗಳ ಪಟ್ಟಿಯಿಂದ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಕರೆನ್ಸಿ ಜೋಡಿಗಳಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದಾರೆ.
import itertools
currencies = ['USD', 'EUR', 'JPY', 'GBP', 'AUD']
exchange_pairs = list(itertools.combinations(currencies, 2))
for pair in exchange_pairs:
print(pair)
ಇದು ಎಲ್ಲಾ ಸಂಭವನೀಯ ಕರೆನ್ಸಿ ಜೋಡಿಗಳನ್ನು ರಚಿಸುತ್ತದೆ, ಇದು ವಿಶ್ಲೇಷಕರಿಗೆ ನಿರ್ದಿಷ್ಟ ವಿನಿಮಯ ದರಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಉದಾಹರಣೆ 2: ಅಂತರರಾಷ್ಟ್ರೀಯ ಶಿಪ್ಪಿಂಗ್ ಮಾರ್ಗ ಆಪ್ಟಿಮೈಸೇಶನ್
ಒಂದು ಲಾಜಿಸ್ಟಿಕ್ಸ್ ಕಂಪನಿಯು ಪ್ರಮುಖ ಅಂತರರಾಷ್ಟ್ರೀಯ ನಗರಗಳ ನಡುವೆ ಶಿಪ್ಪಿಂಗ್ ಮಾರ್ಗಗಳನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಬೇಕಾಗಿದೆ. ಅವರು ನಿರ್ದಿಷ್ಟ ನಗರಗಳ ಗುಂಪಿಗೆ ಭೇಟಿ ನೀಡುವ ಕಡಿಮೆ ಮಾರ್ಗವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಬಯಸುತ್ತಾರೆ.
import itertools
# This is a simplified example, route optimization usually involves distance calculations
cities = ['London', 'Tokyo', 'New York', 'Sydney']
possible_routes = list(itertools.permutations(cities))
# In a real-world scenario, you would calculate the total distance for each route
# and select the shortest one.
for route in possible_routes:
print(route)
ಈ ಉದಾಹರಣೆಯು ಎಲ್ಲಾ ಸಂಭವನೀಯ ಮಾರ್ಗಗಳನ್ನು ರಚಿಸುತ್ತದೆ, ಮತ್ತು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಅಲ್ಗಾರಿದಮ್ ನಂತರ ಪ್ರತಿ ಮಾರ್ಗಕ್ಕೆ ಒಟ್ಟು ದೂರವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅತ್ಯುತ್ತಮವಾದದನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ.
ಉದಾಹರಣೆ 3: ಜಾಗತಿಕ ಉತ್ಪನ್ನ ಕಾನ್ಫಿಗರೇಶನ್
ಒಂದು ಅಂತರರಾಷ್ಟ್ರೀಯ ತಯಾರಕರು ವಿವಿಧ ಪ್ರದೇಶಗಳಿಗೆ ವಿವಿಧ ಆಯ್ಕೆಗಳೊಂದಿಗೆ ಗ್ರಾಹಕೀಯಗೊಳಿಸಬಹುದಾದ ಉತ್ಪನ್ನಗಳನ್ನು ನೀಡುತ್ತಾರೆ. ಲಭ್ಯವಿರುವ ಆಯ್ಕೆಗಳ ಆಧಾರದ ಮೇಲೆ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಉತ್ಪನ್ನ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ಅವರು ಬಯಸುತ್ತಾರೆ.
import itertools
# Example product configuration options
regions = ['North America', 'Europe', 'Asia']
languages = ['English', 'French', 'Japanese']
currencies = ['USD', 'EUR', 'JPY']
product_configurations = list(itertools.product(regions, languages, currencies))
for config in product_configurations:
print(config)
ಈ ಉದಾಹರಣೆಯು ಪ್ರದೇಶ, ಭಾಷೆ ಮತ್ತು ಕರೆನ್ಸಿಯ ಎಲ್ಲಾ ಸಂಭವನೀಯ ಸಂಯೋಜನೆಗಳನ್ನು ರಚಿಸುತ್ತದೆ, ಇದು ತಯಾರಕರಿಗೆ ತಮ್ಮ ಉತ್ಪನ್ನಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಮಾರುಕಟ್ಟೆಗಳಿಗೆ ತಕ್ಕಂತೆ ರೂಪಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
Itertools ಬಳಸುವಾಗ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
- ಮೆಮೊರಿ ದಕ್ಷತೆ:
itertoolsಕಾರ್ಯಗಳು ಇಟೆರೇಟರ್‌ಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ, ಇವು ಬೇಡಿಕೆಯ ಮೇರೆಗೆ ಮೌಲ್ಯಗಳನ್ನು ರಚಿಸುತ್ತವೆ. ಇದು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಹೆಚ್ಚು ಮೆಮೊರಿ-ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ. - ದೊಡ್ಡ ಇಟೆರೇಟರ್‌ಗಳನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ: ಫಲಿತಾಂಶವು ತುಂಬಾ ದೊಡ್ಡದಾಗಿದ್ದರೆ ಇಟೆರೇಟರ್‌ಗಳನ್ನು ಪಟ್ಟಿಗಳಿಗೆ ಪರಿವರ್ತಿಸುವಾಗ (ಉದಾಹರಣೆಗೆ,
list(itertools.product(...))) ಎಚ್ಚರಿಕೆಯಿಂದಿರಿ. ಇಟೆರೇಟರ್ ಅನ್ನು ಚಂಕ್‌ಗಳಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದನ್ನು ಅಥವಾ ಅದನ್ನು ನೇರವಾಗಿ ಲೂಪ್‌ನಲ್ಲಿ ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. - ಇಟೆರೇಟರ್‌ಗಳನ್ನು ಜೋಡಿಸುವುದು:
itertoolsಕಾರ್ಯಗಳನ್ನು ಸಂಕೀರ್ಣ ಡೇಟಾ ಪ್ರಕ್ರಿಯೆ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ರಚಿಸಲು ಒಟ್ಟಿಗೆ ಜೋಡಿಸಬಹುದು. ಇದು ಶಕ್ತಿಯುತ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಪರಿಹಾರಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. - ಔಟ್‌ಪುಟ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ: ಪ್ರತಿ ಕಾರ್ಯದಿಂದ ರಚಿಸಲಾದ ಔಟ್‌ಪುಟ್‌ನ ಕ್ರಮ ಮತ್ತು ರಚನೆಯನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ವಿವರಗಳಿಗಾಗಿ ದಾಖಲಾತಿಯನ್ನು ನೋಡಿ.
- ಓದುವಿಕೆ:
itertoolsಸಂಕ್ಷಿಪ್ತ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗಬಹುದಾದರೂ, ನಿಮ್ಮ ಕೋಡ್ ಓದಲು ಸುಲಭವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಅರ್ಥಪೂರ್ಣ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ ಮತ್ತು ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವಿವರಿಸಲು ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಸೇರಿಸಿ.
ಸುಧಾರಿತ ತಂತ್ರಗಳು ಮತ್ತು ಪರಿಗಣನೆಗಳು
ಸಂಯೋಜಿತ ಕಾರ್ಯಗಳೊಂದಿಗೆ starmap() ಅನ್ನು ಬಳಸುವುದು
itertools ನಿಂದ starmap() ಕಾರ್ಯವನ್ನು ಸಂಯೋಜಿತ ಕಾರ್ಯಗಳಿಂದ ರಚಿಸಲಾದ ಪ್ರತಿ ಸಂಯೋಜನೆಗೆ ಕಾರ್ಯವನ್ನು ಅನ್ವಯಿಸಲು ಬಳಸಬಹುದು. ಪ್ರತಿ ಸಂಯೋಜನೆಯ ಮೇಲೆ ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.
import itertools
numbers = [1, 2, 3, 4]
# Calculate the sum of squares for each combination of two numbers
def sum_of_squares(x, y):
return x**2 + y**2
combinations = itertools.combinations(numbers, 2)
results = list(itertools.starmap(sum_of_squares, combinations))
print(results)
ಸಂಯೋಜನೆಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು
ನಿರ್ದಿಷ್ಟ ಮಾನದಂಡಗಳನ್ನು ಪೂರೈಸುವ ಸಂಯೋಜನೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನೀವು ಫಿಲ್ಟರಿಂಗ್ ತಂತ್ರಗಳನ್ನು ಬಳಸಬಹುದು. ಇದನ್ನು ಪಟ್ಟಿ ಕಾಂಪ್ರಹೆನ್ಷನ್‌ಗಳು ಅಥವಾ filter() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಮಾಡಬಹುದು.
import itertools
numbers = [1, 2, 3, 4, 5, 6]
# Generate combinations of three numbers where the sum is greater than 10
combinations = itertools.combinations(numbers, 3)
filtered_combinations = [comb for comb in combinations if sum(comb) > 10]
print(filtered_combinations)
ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವುದು
ತುಂಬಾ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಸಂಪೂರ್ಣ ಫಲಿತಾಂಶವನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುವುದನ್ನು ತಪ್ಪಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ಮೆಮೊರಿ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಇಟೆರೇಟರ್ ಅನ್ನು ಚಂಕ್‌ಗಳಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ ಅಥವಾ ಅದನ್ನು ನೇರವಾಗಿ ಲೂಪ್‌ನಲ್ಲಿ ಬಳಸಿ.
import itertools
# Process combinations in chunks
def process_combinations(data, chunk_size):
iterator = itertools.combinations(data, 2)
while True:
chunk = list(itertools.islice(iterator, chunk_size))
if not chunk:
break
# Process the chunk
for combination in chunk:
print(combination)
large_data = range(1000)
process_combinations(large_data, 100)
ತೀರ್ಮಾನ
ಪೈಥಾನ್‌ನ itertools ಮಾಡ್ಯೂಲ್ ಸಂಯೋಜನೆಗಳು, ಪರ್ಮುಟೇಶನ್‌ಗಳು ಮತ್ತು ಇತರ ಡೇಟಾ ವ್ಯವಸ್ಥೆಗಳನ್ನು ರಚಿಸಲು ಶಕ್ತಿಯುತ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಸಂಯೋಜಿತ ಇಟೆರೇಟರ್ ಕಾರ್ಯಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಸಂಕ್ಷಿಪ್ತ, ಮೆಮೊರಿ-ಪರಿಣಾಮಕಾರಿ ಕೋಡ್ ಬರೆಯಬಹುದು. ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ರಚಿಸುವುದರಿಂದ ಹಿಡಿದು ಶಿಪ್ಪಿಂಗ್ ಮಾರ್ಗಗಳನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸುವವರೆಗೆ, ಸಾಧ್ಯತೆಗಳು ಅಪಾರ. ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳು ಮತ್ತು ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಿರ್ವಹಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಮತ್ತು ಸುಧಾರಿತ ತಂತ್ರಗಳನ್ನು ಪರಿಗಣಿಸಲು ಮರೆಯದಿರಿ. ಜಾಗತಿಕ ದೃಷ್ಟಿಕೋನದಿಂದ ಈ ಉಪಕರಣಗಳನ್ನು ಬಳಸುವುದರ ಮೂಲಕ, ನೀವು ಅನೇಕ ವಿಭಿನ್ನ ಕೈಗಾರಿಕೆಗಳು ಮತ್ತು ಸಂಸ್ಕೃತಿಗಳಲ್ಲಿ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬಹುದು.
ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್‌ನಲ್ಲಿ ಒದಗಿಸಲಾದ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಪ್ರಯೋಗಿಸಿ ಮತ್ತು ಈ ಶಕ್ತಿಯುತ ಕಾರ್ಯಗಳ ಸಂಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಲು itertools ದಾಖಲಾತಿಯನ್ನು ಅನ್ವೇಷಿಸಿ. ಸಂತೋಷದ ಪುನರಾವರ್ತನೆ!